/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "通用插座.h"

#include "C_粒子插座.h"
#include "节点/插座/list/list物体插座.h"




C_引用数据插座::C_引用数据插座(std::u16string name) :C_插座基类(name, E_值类型::e_插座Type_引用数据) {
	m_引用数据.m_Data = 0;
	m_引用数据.m_Type = E_值类型::e_Type_Bool;
}

C_引用数据插座::~C_引用数据插座() {
	
}

void* C_引用数据插座::f_getData(uint8 当前插座连接线ID) {
	C_插座基类* socket = f_getLinkOutSocket(当前插座连接线ID);
	if (socket) {
		if (socket->m_Type == E_值类型::e_插座Type_引用数据) {
			return (S_引用插座数据映射*)(socket)->f_getData(当前插座连接线ID);

		} /*else if (socket->m_Type == E_值类型::e_插座Type_Rect32f_Array1D) {
			m_引用数据.m_Type = E_值类型::e_插座Type_Rect32f_Array1D;
			m_引用数据.m_几何体 = socket->f_getData(线程ID);

		} */
		else if (socket->m_Type == E_值类型::e_插座Type_通用取) {
			auto& 通用数据插座 = *DEF_通用数据插座(socket, 当前插座连接线ID);
			m_引用数据.m_Type = 通用数据插座.m_插座数据类型;
			m_引用数据.m_Data = 通用数据插座.m_Data;
			//m_引用数据.m_几何体 = socket->f_getData(线程ID);
		}
		else if (socket->m_Type == E_值类型::e_Type_Mesh) {
			m_引用数据.m_Data = DEF_网格插座数据(socket, 当前插座连接线ID);
			m_引用数据.m_Type = E_值类型::e_Type_Mesh;
		}
		else if (socket->m_Type == E_值类型::e_Type_Mesh_1D) {
			m_引用数据.m_Data = DEF_网格插座_1D数据(socket, 当前插座连接线ID);
			m_引用数据.m_Type = E_值类型::e_Type_Mesh_1D;
		}
		else if (socket->m_Type == E_值类型::e_Type_Object) {
			m_引用数据.m_Data = DEF_物体插座数据(socket, 当前插座连接线ID);
			m_引用数据.m_Type = E_值类型::e_Type_Object;
		}
		else if (socket->m_Type == E_值类型::e_Type_Object_Array1D) {
			m_引用数据.m_Data = DEF_对象1D插座Value(socket, 当前插座连接线ID);
			m_引用数据.m_Type = E_值类型::e_Type_Object_Array1D;
		}
		else if (socket->m_Type == E_值类型::e_插座Type_物理体_Array1D) {
			m_引用数据.m_Data = socket->f_getData(当前插座连接线ID);
			m_引用数据.m_Type = E_值类型::e_插座Type_物理体_Array1D;
		}
		else if (socket->m_Type == E_值类型::e_Type_ParticleSystem) {
			auto* 粒子 = DEF_粒子插座Value(socket, 当前插座连接线ID);
			m_引用数据.m_Type = socket->m_Type;
			m_引用数据.m_Data = 粒子;
			//m_引用数据.m_几何体 = socket->f_getData(线程ID);
		} 
		//else if (socket->m_Type == E_值类型::e_Type_骨骼) {
		//}
		else {
			m_引用数据.m_Type = socket->m_Type;
			m_引用数据.m_Data = socket->f_getData(当前插座连接线ID);
		}
	}
	else {
		m_引用数据 = { E_值类型::e_Type_None, nullptr };
	}

	return &m_引用数据;
}

void C_引用数据插座::f_setData(void* data, uint8 线程ID) {
	m_引用数据.m_Data = data;
}

void C_引用数据插座::f_setData(S_引用插座数据映射* data, uint8 线程ID) {
	
}










C_通用数据插座::C_通用数据插座(std::u16string name) :C_插座基类(name, E_值类型::e_插座Type_通用取) {
	m_Data = 0;
	m_插座数据类型 = E_值类型::e_Type_None;
}

C_通用数据插座::~C_通用数据插座() {
}

void* C_通用数据插座::f_getData(uint8 线程ID) {
	C_插座基类* socket = f_getLinkOutSocket();
	if (socket) {
		if (socket->m_Type == E_值类型::e_插座Type_Rect32f) {
			return (socket)->f_getData(线程ID);
		}
	}

	return m_Data;
}

std::vector<S_Rect2Df>* C_通用数据插座::f_getRect2Df_1D(uint8 线程ID) {
	C_插座基类* socket = f_getLinkOutSocket();
	if (socket) {
		if (socket->m_Type == E_值类型::e_插座Type_Rect32f) {
			return (std::vector<S_Rect2Df>*)(socket)->f_getData(线程ID);
		}
	}

	return (std::vector<S_Rect2Df>*)(m_Data);
}

void C_通用数据插座::f_setData(void* data, uint8 线程ID) {
	m_Data = data;
}





C_板载缓存插座::C_板载缓存插座(std::u16string name) :C_插座基类(name, E_值类型::e_Type_GPU缓存1D) {

}

C_板载缓存插座::~C_板载缓存插座()
{
}

void* C_板载缓存插座::f_getData(uint8 线程ID) {
	uint16 num = f_getLinkNum();

	m_Value.clear();
	
	C_插座基类* socket = f_getLinkOutSocket(线程ID);
	if (socket) {
		if (socket->m_Type == E_值类型::e_Type_GPU缓存1D) {
			m_Value = *DEF_板载缓存插座_1D数据(socket, 0);
		}
		else if (socket->m_Type == E_值类型::e_Type_骨骼) {
				
		}
		else if (socket->m_Type == E_值类型::e_Type_Object_Array1D) {

		}
		else if (socket->m_Type == E_值类型::e_插座Type_引用数据) {

		}
	}
	

	return &m_Value;
}

void C_板载缓存插座::f_setData(void* data, uint8 线程ID) {
	C_插座基类::f_setData(data);
	if (data) {
		m_Value = *((std::vector<S_板载缓存*>*)data);
	}
	else {
		m_Value.clear();
	}
}

void C_板载缓存插座::f_读取(FILE* f) {
	C_插座基类::f_读取(f);
}

void C_板载缓存插座::f_写入(FILE* f) {
	C_插座基类::f_写入(f);
}




static S_自定义结构插座数据 g默认数据 = { 0, nullptr, nullptr };

C_自定义结构插座::C_自定义结构插座(std::u16string name) :C_插座基类(name, E_值类型::e_Type_自定义结构) {
	m_Value = &g默认数据;
}

C_自定义结构插座::~C_自定义结构插座() {
	//if (m_Value != &g默认数据) {
	//	free(m_Value);
	//}
}

void* C_自定义结构插座::f_getData(uint8 线程ID) {
	C_插座基类* socket = f_getLinkOutSocket(线程ID);
	if (socket) {
		switch (socket->m_Type) {
			case E_值类型::e_Type_自定义结构: {
				return socket->f_getData(线程ID);
			}
			default:
				break;
		}

		m_Value = &g默认数据;
	}
	else if (!m_映射指针) {
		m_Value = &g默认数据;
	}
	return m_Value;
}

void C_自定义结构插座::f_setData(void* data, uint8 线程ID) {
	C_插座基类::f_setData(data, 0);
	m_Value = (S_自定义结构插座数据*)data;
}
bool C_自定义结构插座::f_接入插座是否匹配(E_值类型 type) {
	switch (type) {
		case E_值类型::e_Type_自定义结构:
			return true;
	}
	return false;
}

void C_自定义结构插座::f_读取(FILE* f) {
	C_插座基类::f_读取(f);
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_插座实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;
		if (f_file_版本对比(文件块, S_引擎配置::g_低版本号_0, S_引擎配置::g_文件版本号)) {
			uint64 字节数 = 0;
			下一次读取数据指针 = f_文件块_读数据块(下一次读取数据指针, 字节数);

			if (m_Value->m_字节大小 == 字节数) {
				if (m_Value->mf_加载) {
					下一次读取数据指针 = m_Value->mf_加载(this, (S_结构指针)m_Value, 下一次读取数据指针);
				}
			}
		}
	}
	free(文件块.m_data);
}

void C_自定义结构插座::f_写入(FILE* f) {
	C_插座基类::f_写入(f);
	auto 文件块 = f_文件块_创建(E_节点工程文件块类型::e_工程文件块_插座实例属性, S_引擎配置::g_文件版本号);

	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	f_文件块_写数据块(块, m_Value->m_字节大小);
	if (m_Value->m_字节大小) {
		if (m_Value->mf_保存) {
			m_Value->mf_保存(this, (S_结构指针)m_Value, 块);
		}
	}

	f_file_保存文件块(f, 文件块, 块);
}
